home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / textwrap.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2014-12-31  |  12KB  |  317 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. '''Text wrapping and filling.
  5. '''
  6. __revision__ = '$Id$'
  7. import string
  8. import re
  9.  
  10. try:
  11.     _unicode = unicode
  12. except NameError:
  13.     
  14.     class _unicode(object):
  15.         pass
  16.  
  17.  
  18. __all__ = [
  19.     'TextWrapper',
  20.     'wrap',
  21.     'fill',
  22.     'dedent']
  23. _whitespace = '\t\n\x0b\x0c\r '
  24.  
  25. class TextWrapper:
  26.     '''
  27.     Object for wrapping/filling text.  The public interface consists of
  28.     the wrap() and fill() methods; the other methods are just there for
  29.     subclasses to override in order to tweak the default behaviour.
  30.     If you want to completely replace the main wrapping algorithm,
  31.     you\'ll probably have to override _wrap_chunks().
  32.  
  33.     Several instance attributes control various aspects of wrapping:
  34.       width (default: 70)
  35.         the maximum width of wrapped lines (unless break_long_words
  36.         is false)
  37.       initial_indent (default: "")
  38.         string that will be prepended to the first line of wrapped
  39.         output.  Counts towards the line\'s width.
  40.       subsequent_indent (default: "")
  41.         string that will be prepended to all lines save the first
  42.         of wrapped output; also counts towards each line\'s width.
  43.       expand_tabs (default: true)
  44.         Expand tabs in input text to spaces before further processing.
  45.         Each tab will become 1 .. 8 spaces, depending on its position in
  46.         its line.  If false, each tab is treated as a single character.
  47.       replace_whitespace (default: true)
  48.         Replace all whitespace characters in the input text by spaces
  49.         after tab expansion.  Note that if expand_tabs is false and
  50.         replace_whitespace is true, every tab will be converted to a
  51.         single space!
  52.       fix_sentence_endings (default: false)
  53.         Ensure that sentence-ending punctuation is always followed
  54.         by two spaces.  Off by default because the algorithm is
  55.         (unavoidably) imperfect.
  56.       break_long_words (default: true)
  57.         Break words longer than \'width\'.  If false, those words will not
  58.         be broken, and some lines might be longer than \'width\'.
  59.       break_on_hyphens (default: true)
  60.         Allow breaking hyphenated words. If true, wrapping will occur
  61.         preferably on whitespaces and right after hyphens part of
  62.         compound words.
  63.       drop_whitespace (default: true)
  64.         Drop leading and trailing whitespace from lines.
  65.     '''
  66.     whitespace_trans = string.maketrans(_whitespace, ' ' * len(_whitespace))
  67.     unicode_whitespace_trans = { }
  68.     uspace = ord(u' ')
  69.     for x in map(ord, _whitespace):
  70.         unicode_whitespace_trans[x] = uspace
  71.     
  72.     wordsep_re = re.compile('(\\s+|[^\\s\\w]*\\w+[^0-9\\W]-(?=\\w+[^0-9\\W])|(?<=[\\w\\!\\"\\\'\\&\\.\\,\\?])-{2,}(?=\\w))')
  73.     wordsep_simple_re = re.compile('(\\s+)')
  74.     sentence_end_re = re.compile('[%s][\\.\\!\\?][\\"\\\']?\\Z' % string.lowercase)
  75.     
  76.     def __init__(self, width = 70, initial_indent = '', subsequent_indent = '', expand_tabs = True, replace_whitespace = True, fix_sentence_endings = False, break_long_words = True, drop_whitespace = True, break_on_hyphens = True):
  77.         self.width = width
  78.         self.initial_indent = initial_indent
  79.         self.subsequent_indent = subsequent_indent
  80.         self.expand_tabs = expand_tabs
  81.         self.replace_whitespace = replace_whitespace
  82.         self.fix_sentence_endings = fix_sentence_endings
  83.         self.break_long_words = break_long_words
  84.         self.drop_whitespace = drop_whitespace
  85.         self.break_on_hyphens = break_on_hyphens
  86.         self.wordsep_re_uni = re.compile(self.wordsep_re.pattern, re.U)
  87.         self.wordsep_simple_re_uni = re.compile(self.wordsep_simple_re.pattern, re.U)
  88.  
  89.     
  90.     def _munge_whitespace(self, text):
  91.         '''_munge_whitespace(text : string) -> string
  92.  
  93.         Munge whitespace in text: expand tabs and convert all other
  94.         whitespace characters to spaces.  Eg. " foo\tbar
  95.  
  96. baz"
  97.         becomes " foo    bar  baz".
  98.         '''
  99.         if self.expand_tabs:
  100.             text = text.expandtabs()
  101.         if self.replace_whitespace:
  102.             if isinstance(text, str):
  103.                 text = text.translate(self.whitespace_trans)
  104.             elif isinstance(text, _unicode):
  105.                 text = text.translate(self.unicode_whitespace_trans)
  106.             
  107.         return text
  108.  
  109.     
  110.     def _split(self, text):
  111.         """_split(text : string) -> [string]
  112.  
  113.         Split the text to wrap into indivisible chunks.  Chunks are
  114.         not quite the same as words; see _wrap_chunks() for full
  115.         details.  As an example, the text
  116.           Look, goof-ball -- use the -b option!
  117.         breaks into the following chunks:
  118.           'Look,', ' ', 'goof-', 'ball', ' ', '--', ' ',
  119.           'use', ' ', 'the', ' ', '-b', ' ', 'option!'
  120.         if break_on_hyphens is True, or in:
  121.           'Look,', ' ', 'goof-ball', ' ', '--', ' ',
  122.           'use', ' ', 'the', ' ', '-b', ' ', option!'
  123.         otherwise.
  124.         """
  125.         if isinstance(text, _unicode):
  126.             if self.break_on_hyphens:
  127.                 pat = self.wordsep_re_uni
  128.             else:
  129.                 pat = self.wordsep_simple_re_uni
  130.         elif self.break_on_hyphens:
  131.             pat = self.wordsep_re
  132.         else:
  133.             pat = self.wordsep_simple_re
  134.         chunks = pat.split(text)
  135.         chunks = filter(None, chunks)
  136.         return chunks
  137.  
  138.     
  139.     def _fix_sentence_endings(self, chunks):
  140.         '''_fix_sentence_endings(chunks : [string])
  141.  
  142.         Correct for sentence endings buried in \'chunks\'.  Eg. when the
  143.         original text contains "... foo.
  144. Bar ...", munge_whitespace()
  145.         and split() will convert that to [..., "foo.", " ", "Bar", ...]
  146.         which has one too few spaces; this method simply changes the one
  147.         space to two.
  148.         '''
  149.         i = 0
  150.         patsearch = self.sentence_end_re.search
  151.         while i < len(chunks) - 1:
  152.             if chunks[i + 1] == ' ' and patsearch(chunks[i]):
  153.                 chunks[i + 1] = '  '
  154.                 i += 2
  155.                 continue
  156.             i += 1
  157.  
  158.     
  159.     def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
  160.         '''_handle_long_word(chunks : [string],
  161.                              cur_line : [string],
  162.                              cur_len : int, width : int)
  163.  
  164.         Handle a chunk of text (most likely a word, not whitespace) that
  165.         is too long to fit in any line.
  166.         '''
  167.         if width < 1:
  168.             space_left = 1
  169.         else:
  170.             space_left = width - cur_len
  171.         if self.break_long_words:
  172.             cur_line.append(reversed_chunks[-1][:space_left])
  173.             reversed_chunks[-1] = reversed_chunks[-1][space_left:]
  174.         elif not cur_line:
  175.             cur_line.append(reversed_chunks.pop())
  176.  
  177.     
  178.     def _wrap_chunks(self, chunks):
  179.         '''_wrap_chunks(chunks : [string]) -> [string]
  180.  
  181.         Wrap a sequence of text chunks and return a list of lines of
  182.         length \'self.width\' or less.  (If \'break_long_words\' is false,
  183.         some lines may be longer than this.)  Chunks correspond roughly
  184.         to words and the whitespace between them: each chunk is
  185.         indivisible (modulo \'break_long_words\'), but a line break can
  186.         come between any two chunks.  Chunks should not have internal
  187.         whitespace; ie. a chunk is either all whitespace or a "word".
  188.         Whitespace chunks will be removed from the beginning and end of
  189.         lines, but apart from that whitespace is preserved.
  190.         '''
  191.         lines = []
  192.         if self.width <= 0:
  193.             raise ValueError('invalid width %r (must be > 0)' % self.width)
  194.         chunks.reverse()
  195.         while chunks:
  196.             cur_line = []
  197.             cur_len = 0
  198.             if lines:
  199.                 indent = self.subsequent_indent
  200.             else:
  201.                 indent = self.initial_indent
  202.             width = self.width - len(indent)
  203.             if self.drop_whitespace and chunks[-1].strip() == '' and lines:
  204.                 del chunks[-1]
  205.             while chunks:
  206.                 l = len(chunks[-1])
  207.                 if cur_len + l <= width:
  208.                     cur_line.append(chunks.pop())
  209.                     cur_len += l
  210.                     continue
  211.                 break
  212.             if chunks and len(chunks[-1]) > width:
  213.                 self._handle_long_word(chunks, cur_line, cur_len, width)
  214.             if self.drop_whitespace and cur_line and cur_line[-1].strip() == '':
  215.                 del cur_line[-1]
  216.             if cur_line:
  217.                 lines.append(indent + ''.join(cur_line))
  218.                 continue
  219.             return lines
  220.  
  221.     
  222.     def wrap(self, text):
  223.         """wrap(text : string) -> [string]
  224.  
  225.         Reformat the single paragraph in 'text' so it fits in lines of
  226.         no more than 'self.width' columns, and return a list of wrapped
  227.         lines.  Tabs in 'text' are expanded with string.expandtabs(),
  228.         and all other whitespace characters (including newline) are
  229.         converted to space.
  230.         """
  231.         text = self._munge_whitespace(text)
  232.         chunks = self._split(text)
  233.         if self.fix_sentence_endings:
  234.             self._fix_sentence_endings(chunks)
  235.         return self._wrap_chunks(chunks)
  236.  
  237.     
  238.     def fill(self, text):
  239.         """fill(text : string) -> string
  240.  
  241.         Reformat the single paragraph in 'text' to fit in lines of no
  242.         more than 'self.width' columns, and return a new string
  243.         containing the entire wrapped paragraph.
  244.         """
  245.         return '\n'.join(self.wrap(text))
  246.  
  247.  
  248.  
  249. def wrap(text, width = 70, **kwargs):
  250.     """Wrap a single paragraph of text, returning a list of wrapped lines.
  251.  
  252.     Reformat the single paragraph in 'text' so it fits in lines of no
  253.     more than 'width' columns, and return a list of wrapped lines.  By
  254.     default, tabs in 'text' are expanded with string.expandtabs(), and
  255.     all other whitespace characters (including newline) are converted to
  256.     space.  See TextWrapper class for available keyword args to customize
  257.     wrapping behaviour.
  258.     """
  259.     w = TextWrapper(width = width, **kwargs)
  260.     return w.wrap(text)
  261.  
  262.  
  263. def fill(text, width = 70, **kwargs):
  264.     """Fill a single paragraph of text, returning a new string.
  265.  
  266.     Reformat the single paragraph in 'text' to fit in lines of no more
  267.     than 'width' columns, and return a new string containing the entire
  268.     wrapped paragraph.  As with wrap(), tabs are expanded and other
  269.     whitespace characters converted to space.  See TextWrapper class for
  270.     available keyword args to customize wrapping behaviour.
  271.     """
  272.     w = TextWrapper(width = width, **kwargs)
  273.     return w.fill(text)
  274.  
  275. _whitespace_only_re = re.compile('^[ \t]+$', re.MULTILINE)
  276. _leading_whitespace_re = re.compile('(^[ \t]*)(?:[^ \t\n])', re.MULTILINE)
  277.  
  278. def dedent(text):
  279.     '''Remove any common leading whitespace from every line in `text`.
  280.  
  281.     This can be used to make triple-quoted strings line up with the left
  282.     edge of the display, while still presenting them in the source code
  283.     in indented form.
  284.  
  285.     Note that tabs and spaces are both treated as whitespace, but they
  286.     are not equal: the lines "  hello" and "\thello" are
  287.     considered to have no common leading whitespace.  (This behaviour is
  288.     new in Python 2.5; older versions of this module incorrectly
  289.     expanded tabs before searching for common leading whitespace.)
  290.     '''
  291.     margin = None
  292.     text = _whitespace_only_re.sub('', text)
  293.     indents = _leading_whitespace_re.findall(text)
  294.     for indent in indents:
  295.         if margin is None:
  296.             margin = indent
  297.             continue
  298.         if indent.startswith(margin):
  299.             continue
  300.         if margin.startswith(indent):
  301.             margin = indent
  302.             continue
  303.         margin = ''
  304.         break
  305.     
  306.     if 0 and margin:
  307.         for line in text.split('\n'):
  308.             if not not line and line.startswith(margin):
  309.                 raise AssertionError('line = %r, margin = %r' % (line, margin))
  310.         
  311.     if margin:
  312.         text = re.sub('(?m)^' + margin, '', text)
  313.     return text
  314.  
  315. if __name__ == '__main__':
  316.     print dedent('Hello there.\n  This is indented.')
  317.